home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1996 March / EnigmA AMIGA RUN 05 (1996)(G.R. Edizioni)(IT)[!][issue 1996-03][Skylink CD IV].iso / earcd / util1 / patchgui.lha / patchGUI.c < prev    next >
C/C++ Source or Header  |  1995-11-02  |  21KB  |  611 lines
  1. /* RCS:
  2. ** $Id$
  3. **
  4. ** PatchGUI.c © Aris Basic
  5. **
  6. **
  7. */
  8.  
  9. /*FOLDER Global Vars,Includes,Declarations,Macros
  10. */
  11. #include <custom/mui_standard.h>
  12. #include <string.h>
  13. //#include "patchGUI_cat.h"
  14.  
  15. struct LocaleBase *LocaleBase;
  16. struct Library *IconBase;
  17. struct Catalog *mycatalog;
  18.  
  19. #define setmnlabel(number,label,comm) mn_data[number].nm_Label=getstring(label);\
  20.                                       mn_data[number].nm_CommKey=((comm)?getstring(comm):0)
  21. #define sepBAR RectangleObject,\
  22.                MUIA_Rectangle_HBar,TRUE,\
  23.                MUIA_FixHeight,15,\
  24.                End
  25. #define textGAD(txt,prep) TextObject,\
  26.                           MUIA_Background,MUII_TextBack,\
  27.                           MUIA_Frame,MUIV_Frame_Text,\
  28.                           MUIA_Text_Contents,(char *)txt,\
  29.                           MUIA_Text_PreParse,(prep?prep:""),\
  30.                           MUIA_Text_SetMin,TRUE,\
  31.                           End
  32. #define ENVPATH "ENV:PATCHGUI"
  33. #define ENVARCPATH "ENVARC:PATCHGUI"
  34. #define ARGPAT "PRGNAME/K/A,FORMAT/K/A"
  35. #define NAVODNIK '"'
  36.  
  37. enum { ID_DELETE=1,ID_EDIT,ID_CONFIG,ID_CONFIGC,ID_CONFIGOK,ID_DO,};
  38.  
  39. APTR App,win,configroup;
  40. APTR bt_quit,bt_do,info;
  41. APTR dlist,bt_delete,bt_edit;
  42. APTR confwin,str_prg,pop_prg,str_name,str_format;
  43. APTR str_info,bt_c_cancel,bt_c_ok;
  44. APTR str_fnew,str_fold,str_fpatch,pop_fnew,pop_fold,pop_fpatch;
  45. APTR bt_c_help,bt_about;
  46.  
  47. struct mydata {
  48.     char name[35];
  49.     char prgname[35];
  50.     char format[60];
  51.     char info[256];
  52.     };
  53.  
  54. struct myarg {
  55.     char *prgname;
  56.     char *format;
  57.     };
  58.  
  59. struct mydata data;
  60. int error;
  61. struct FileInfoBlock *cname;
  62. char help[256];
  63. /*END*/
  64. /*
  65. ** Procedure cpyfileENV (Copy Config To Env)
  66. **
  67. ** void cpyfileEMV(char *name)
  68. **
  69. ** INPUT:
  70. ** char *name <- Filename without Path
  71. **
  72. ** OUTPUT:
  73. ** none
  74. **
  75. */
  76. /*FOLDER cpyfileENV
  77. */
  78. void cpyfileENV(char *name)
  79. {
  80.     char *envname=(char *)malloc(sizeof(char)*256);
  81.     char *envarcname=(char *)malloc(sizeof(char)*256);
  82.     char *buffer=(char *)malloc(sizeof(char)*256);
  83.  
  84.     sprintf(envname,"%s/%s",ENVPATH,name);
  85.     sprintf(envarcname,"%s/%s",ENVARCPATH,name);
  86.     sprintf(buffer,"copy %s TO %s QUIET",envarcname,envname);
  87.     System(buffer,TAG_DONE);
  88.     }
  89. /*END*/
  90. /*
  91. ** Function rconfig (ReadConfig)
  92. **
  93. ** struct mydata config=rconfig(char *name)
  94. **
  95. ** INPUT:
  96. ** char *name <- Name of Config File
  97. **               (ENV:PATCHGUI/ will be added to name)
  98. **
  99. ** OUTPUT:
  100. ** struct mydata *config <- Readed Configuration
  101. ** config.name == NULL if somthings wrong in Configuration
  102. ** config.info == Error Text
  103. **
  104. */
  105. /*FOLDER ReadConfig
  106. */
  107. struct mydata rconfig(char *name)
  108. {
  109.     BPTR conf;
  110.     struct mydata rconf;
  111.     char *rname=(char *)malloc(sizeof(char)*256),*cinfo=(char *)malloc(sizeof(char)*256);
  112.     char *confline=(char *)malloc(sizeof(char)*256);
  113.     struct myarg args;
  114.     struct RDArgs *rdargs;
  115.  
  116.     sprintf(rname,"%s/%s",ENVPATH,name);
  117.     if (conf=Open(rname,MODE_OLDFILE)) {
  118.         FGets(conf,confline,256);
  119.         FGets(conf,cinfo,256);
  120.         Close(conf);
  121.         strcpy(rconf.info,cinfo);
  122.         strcpy(rconf.name,name);
  123.         if ((rdargs=AllocDosObject(DOS_RDARGS,NULL))!=NULL) {
  124.             rdargs->RDA_Source.CS_Buffer=confline;
  125.             rdargs->RDA_Source.CS_Length=strlen(confline);
  126.             rdargs->RDA_Source.CS_CurChr=0;
  127.             rdargs->RDA_DAList=NULL;
  128.             rdargs->RDA_Buffer=NULL;
  129.             rdargs->RDA_Flags=RDAF_NOPROMPT;
  130.             if ((rdargs=ReadArgs(ARGPAT,(long *)&args,rdargs))!=NULL) {
  131.                 strcpy(rconf.prgname,args.prgname);
  132.                 strcpy(rconf.format,args.format);
  133.                 FreeArgs(rdargs);
  134.                 }
  135.             else {
  136.                 strcpy(rconf.info,"Somthing is Wrong With This Config!\nCheck it !!!");
  137.                 strcpy(rconf.prgname,"ERROR");
  138.                 }
  139.             FreeDosObject(DOS_RDARGS,rdargs);
  140.             }
  141.         else {
  142.             strcpy(rconf.info,"Could Not Allocate Memory !");
  143.             strcpy(rconf.prgname,"ERROR");
  144.             }
  145.  
  146.         return(rconf);
  147.     }
  148.     strcpy(rconf.info,"Error With  File!");
  149.     strcpy(rconf.prgname,"ERROR");
  150.     return(rconf);
  151.     }
  152. /*END*/
  153. /*
  154. ** Procedure wconfig (WriteConfig)
  155. **
  156. ** void wconfig(struct mydata data)
  157. **
  158. ** INPUT:
  159. ** struct mydata *data <- Ptr To Structure With Configuration Datas
  160. **
  161. ** OUTPUT:
  162. ** none
  163. **
  164. */
  165. /*FOLDER WriteConfig
  166. */
  167. BOOL wconfig(struct mydata data)
  168. {
  169.     BPTR file,lock;
  170.     char *fullinfo=(char *)malloc(sizeof(char)*256);
  171.     char *fullconfig=(char *)malloc(sizeof(char)*256);
  172.     char *filename=(char *)malloc(sizeof(char)*256);
  173.  
  174.     if (strlen(data.format)<=0) {
  175.         MUI_Request(App,win,NULL,0,"*_OK","There Is No FORMAT In Configuration\n And You must have them !!",TAG_DONE);
  176.         return(FALSE);
  177.         }
  178.     if (data.name!=NULL) {
  179.         sprintf(filename,"%s/%s",ENVARCPATH,data.name);
  180.         if ((file=Open(filename,MODE_NEWFILE))==NULL) {
  181.             if ((lock=CreateDir(ENVARCPATH))==NULL) {
  182.                 puts("Cold Not Save Config");
  183.                 return(FALSE);
  184.                 }
  185.                 UnLock(lock);
  186.             }
  187.         sprintf(fullconfig,"PRGNAME=%s FORMAT=%c%s%c",data.prgname,NAVODNIK,data.format,NAVODNIK);
  188.         sprintf(fullconfig,"%s\n",fullconfig);
  189.         sprintf(fullinfo,"%s\n",data.info);
  190.         FPuts(file,fullconfig);
  191.         FPuts(file,fullinfo);
  192.         Close(file);
  193.         cpyfileENV(data.name);
  194.         return(TRUE);
  195.         }
  196.     }
  197. /*END*/
  198. /*
  199. ** Procedure setconfwin (Set Config Window)
  200. **
  201. ** void setconfwin(struct mydata data)
  202. **
  203. ** INPUT:
  204. ** struct mydata data <- Configuration Structure Reded from File
  205. **
  206. ** OUTPUT:
  207. ** none
  208. **
  209. */
  210. /*FOLDER Set Config Window
  211. */
  212. void setconfwin(struct mydata data)
  213. {
  214.     setstring(str_info,data.info);
  215.     setstring(str_name,data.name);
  216.     setstring(str_prg,data.prgname);
  217.     setstring(str_format,data.format);
  218.     }
  219. /*END*/
  220. /*
  221. ** Procedure getconfwin (Get Config Window)
  222. **
  223. ** struct mydata data=getconfwin(void)
  224. **
  225. ** INPUT:
  226. ** none
  227. **
  228. ** OUTPUT:
  229. ** mydata structure of configuration
  230. **
  231. */
  232. /*FOLDER Get Config Window
  233. */
  234. struct mydata getconfwin(void)
  235. {
  236.     struct mydata data;
  237.     char *help;
  238.  
  239.     getstring(str_info,&help);
  240.     strcpy(data.info,help);
  241.     getstring(str_name,&help);
  242.     strcpy(data.name,help);
  243.     getstring(str_prg,&help);
  244.     strcpy(data.prgname,help);
  245.     getstring(str_format,&help);
  246.     strcpy(data.format,help);
  247.     return(data);
  248.     }
  249. /*END*/
  250. /*
  251. ** Function Parse CommandLine
  252. **
  253. ** char *parsecmdline(struct mydata data)
  254. **
  255. */
  256. /*FOLDER ParseCMDLine
  257. */
  258. char *parsecmdline(struct mydata data,char *filenew,char *fileold,char *filepatch)
  259. {
  260.     char *cmdline=(char *)malloc(sizeof(char)*256);
  261.     char *format=(char *)malloc(sizeof(char)*256);
  262.     char help;
  263.     int a=0;
  264.  
  265.     if ((strlen(data.format)<=0)) return("ERROR");
  266.  
  267.     strcpy(format,data.format);
  268.     sprintf(cmdline,"%s ",data.prgname);
  269.  
  270.     help=format[a++];
  271.  
  272.     while(a<=strlen(format)) {
  273.     switch(help) {
  274.          case '%':
  275.              switch(format[a++]) {
  276.                  case '%':
  277.                      sprintf(cmdline,"%s%c",cmdline,'%');
  278.                      break;
  279.                  case 'f':
  280.                      switch(format[a++]) {
  281.                          case 'n':
  282.                              sprintf(cmdline,"%s%s",cmdline,filenew);
  283.                              break;
  284.                          case 'p':
  285.                              sprintf(cmdline,"%s%s",cmdline,filepatch);
  286.                              break;
  287.                          case 'o':
  288.                              sprintf(cmdline,"%s%s",cmdline,fileold);
  289.                              break;
  290.                          }
  291.                      break;
  292.                  }
  293.              break;
  294.          default:
  295.              sprintf(cmdline,"%s%c",cmdline,help);
  296.              break;
  297.          }
  298.      help=format[a++];
  299.      }
  300.  return(cmdline);
  301.  }
  302.  
  303. /*END*/
  304. /*
  305. ** Hook Function ABout
  306. */
  307. /*FOLDER About HOOK
  308. */
  309. _HOOK_FUNC (void,mabout,struct Hook *hook,APTR obj,APTR dummy)
  310. {
  311.     MUI_Request(App,win,0,NULL,"*_OK","\033c\033bPatchGUI 00.10"
  312.                                       "\033n\n© Aris Basic 1995\n\n"
  313.                                       "Contact me on:\naris@pwe.augusta.de"
  314.                                       "\n\n\033bThis is MUI Application\n"
  315.                                       "MUI © Stefan Stuntz",TAG_DONE);
  316.     }
  317. struct Hook mabout_hook={
  318.        {NULL,NULL},
  319.        (void *)mabout,
  320.        NULL,NULL
  321.        };
  322. /*END*/
  323. /*
  324. ** Hook Function Help
  325. */
  326. /*FOLDER Config Help HOOK
  327. */
  328. _HOOK_FUNC (void,chelp,struct Hook *hook,APTR obj,APTR dummy)
  329. {
  330.     MUI_Request(App,confwin,0,NULL,"*_OK","\033c\033bHELP\n\033nfor Format"
  331.                                       " field:\n\n\033l"
  332.                                       "%%%%  - puts char %% on this place\n"
  333.                                       "%%fo - puts Filename from OldFilename gadget\n"
  334.                                       "%%fn - puts Filename from NewFilename gadget\n"
  335.                                       "%%fp - puts Filename from PatchFilename gadget\n"
  336.                                       "\n\n\033b\033rPatchGUI © Aris Basic",TAG_DONE);
  337.     }
  338. struct Hook chelp_hook={
  339.        {NULL,NULL},
  340.        (void *)chelp,
  341.        NULL,NULL
  342.        };
  343. /*END*/
  344. /*
  345. ** Hook Function Do
  346. */
  347. /*FOLDER Do HOOK
  348. */
  349. _HOOK_FUNC (void,do_that,struct Hook *hook,APTR obj,APTR dummy)
  350. {
  351.     char *fnew,*fold,*fpatch,*cmdline,*infoline=(char *)malloc(sizeof(char)*256);
  352.  
  353.  
  354.     DoMethod(dlist,MUIM_List_GetEntry,MUIV_List_GetEntry_Active,&cname);
  355.  
  356.     if (cname==NULL)
  357.         {
  358.  
  359.             MUI_Request(App,win,0,NULL,"*_OK","\033cYou Haven`t Double Click On Configuration!!",TAG_DONE);
  360.             set(info,MUIA_Text_Contents,"\033bERROR !!!\033n\nYou Haven`t Chose Configuartion!");
  361.             return;
  362.         }
  363.  
  364.     stccpy(help,cname->fib_FileName,strlen(cname->fib_FileName));
  365.     error=Stricmp(data.name,help);
  366.  
  367.     if (!error)
  368.         {
  369.              data=rconfig(cname->fib_FileName);
  370.         }
  371.  
  372.     if (!Stricmp(data.prgname,"ERROR"))
  373.         {
  374.             MUI_Request(App,win,0,NULL,"*_OK","\033cSomthings Wrong With Configuration !\nMaybe it isn`t Loaded ?!\nDouble Click on Configuration for Your Program !!",TAG_END);
  375.             set(info,MUIA_Text_Contents,"Error With Configuration");
  376.             return;
  377.         }
  378.  
  379.     getstring(str_fnew,&fnew);
  380.     getstring(str_fold,&fold);
  381.     getstring(str_fpatch,&fpatch);
  382.     cmdline=parsecmdline(data,fnew,fold,fpatch);
  383.     sprintf(infoline,"\033bNow Doing:\033n\n %s",cmdline);
  384.     set(info,MUIA_Text_Contents,infoline);
  385.     set(win,MUIA_Window_Sleep,TRUE);
  386.     error=System(cmdline,TAG_DONE);
  387.     set(win,MUIA_Window_Sleep,FALSE);
  388.  
  389.     if (error)
  390.         {
  391.         sprintf(infoline,"\033bThere Was Error : %d !!\033n\nProbably Error in Format or Arguments",error);
  392.         set(info,MUIA_Text_Contents,infoline);
  393.         }
  394.     else
  395.         {
  396.             set(info,MUIA_Text_Contents,"\033bDone\n\033nEverything is OK !!");
  397.         }
  398. }
  399.  
  400. struct Hook do_hook = {
  401.     {NULL,NULL},
  402.     (void *)do_that,
  403.     NULL,NULL
  404.     };
  405. /*END*/
  406.  
  407. /*Main*/
  408. /*FOLDER Main
  409. */
  410. void main(void)
  411. {
  412.     BOOL running=TRUE;
  413.     long signals,id;
  414.    
  415.  
  416.     init();
  417. /*FOLDER Configuration Window
  418. */
  419.     confwin=WindowObject,
  420.             MUIA_Window_ID,MAKE_ID('C','O','N','F'),
  421.             MUIA_Window_Title,"PatchGUI Configuration",
  422.             WindowContents,VGroup,
  423.                   Child,textGAD("Configuration Editor","\033c"),
  424.                   Child,sepBAR,
  425.                   Child,ColGroup(2),
  426.                         Child,Label("Config Name"),
  427.                         Child,str_name=StringObject,
  428.                               StringFrame,
  429.                               MUIA_String_MaxLen,35,
  430.                               End,
  431.                         Child,Label("Program Name"),
  432.                         Child,pop_prg=PopaslObject,
  433.                               MUIA_Popstring_String,str_prg=StringObject,
  434.                                                     StringFrame,
  435.                                                     MUIA_String_MaxLen,75,
  436.                                                     End,
  437.                               MUIA_Popstring_Button,PopButton(MUII_PopFile),
  438.                               ASLFR_SleepWindow,TRUE,
  439.                               End,
  440.                         Child,Label("Format"),
  441.                         Child,str_format=StringObject,
  442.                               StringFrame,
  443.                               MUIA_String_MaxLen,50,
  444.                               End,
  445.                         Child,Label("Configuration Info"),
  446.                         Child,str_info=StringObject,
  447.                               StringFrame,
  448.                               MUIA_String_MaxLen,255,
  449.                               End,
  450.                         End,
  451.                   Child,sepBAR,
  452.                   Child,bt_c_help=SimpleButton("Help"),
  453.                   Child,HGroup,
  454.                         Child,bt_c_ok=SimpleButton("Ok"),
  455.                         Child,bt_c_cancel=SimpleButton("Cancel"),
  456.                         End,
  457.                   End,
  458.             End;
  459. /*END*/
  460. /*FOLDER Configuration Group (MaIn Window)
  461. */
  462.     configroup=VGroup,
  463.                       GroupFrameT("Chose Config"),
  464.                           Child,dlist=ListviewObject,
  465.                                 MUIA_Listview_Input,TRUE,
  466.                                 MUIA_Listview_List,DirlistObject,
  467.                                      MUIA_Background,MUII_ListBack,
  468.                                      InputListFrame,
  469.                                      MUIA_Dirlist_Directory,"ENV:PATCHGUI/",
  470.                                      MUIA_Dirlist_FilesOnly,TRUE,
  471.                                      MUIA_List_Format," ",
  472.                                      End,
  473.                                 End,
  474.                           Child,HGroup,
  475.                                 Child,bt_delete=SimpleButton("Delete"),
  476.                                 Child,bt_edit=SimpleButton("Edit"),
  477.                                 End,
  478.                           End;
  479. /*END*/
  480.     App=ApplicationObject,
  481.         MUIA_Application_Title,"PatchGUI",
  482.         MUIA_Application_Version,"$VER: PatchGUI 00.10 (27.10.95)",
  483.         MUIA_Application_Copyright,"© 1995 Aris Basic",
  484.         MUIA_Application_Author,"Aris Basic",
  485.         MUIA_Application_Description,"GUI for spatch and more",
  486.         MUIA_Application_Base,"PATCHGUI",
  487.         MUIA_Application_Window,win=WindowObject,
  488.                                 MUIA_Window_ID,MAKE_ID('M','A','I','N'),
  489.                                 MUIA_Window_Title,"PatchGUI",
  490.                                 WindowContents,VGroup,
  491.                                       Child,textGAD("\0338PatchGUI 00.10 © Aris Basic","\033c"),
  492.                                       Child,info=textGAD("\033bWelcome To PatchGUI\033n\n(Double Click On Configuration  to Use,Edit or Delete it)","\033c"),
  493.                                       Child,HGroup,
  494.                                             Child,ColGroup(2),
  495.                                                   Child,VSpace(8),
  496.                                                   Child,VSpace(8),
  497.                                                   Child,Label("New FileName"),
  498.                                                   Child,pop_fnew=PopaslObject,
  499.                                                         MUIA_Popstring_String,str_fnew=StringObject,
  500.                                                              StringFrame,
  501.                                                              MUIA_String_MaxLen,256,
  502.                                                              End,
  503.                                                         MUIA_Popstring_Button,PopButton(MUII_PopFile),
  504.                                                         ASLFR_SleepWindow,TRUE,
  505.                                                         End,
  506.                                                   Child,Label("Old FileName"),
  507.                                                   Child,pop_fold=PopaslObject,
  508.                                                         MUIA_Popstring_String,str_fold=StringObject,
  509.                                                              StringFrame,
  510.                                                              MUIA_String_MaxLen,256,
  511.                                                              End,
  512.                                                         MUIA_Popstring_Button,PopButton(MUII_PopFile),
  513.                                                         ASLFR_SleepWindow,TRUE,
  514.                                                         End,
  515.                                                   Child,Label("Patch FileName"),
  516.                                                   Child,pop_fpatch=PopaslObject,
  517.                                                         MUIA_Popstring_String,str_fpatch=StringObject,
  518.                                                              StringFrame,
  519.                                                              MUIA_String_MaxLen,256,
  520.                                                              End,
  521.                                                         MUIA_Popstring_Button,PopButton(MUII_PopFile),
  522.                                                         ASLFR_SleepWindow,TRUE,
  523.                                                         End,
  524.                                                   Child,VSpace(4),
  525.                                                   Child,VSpace(4),
  526.                                                   End,
  527.                                              Child,configroup,
  528.                                              End,
  529.                                        Child,sepBAR,
  530.                                        Child,bt_about=SimpleButton("About"),
  531.                                        Child,HGroup,
  532.                                              Child,bt_do=SimpleButton("Do"),
  533.                                              Child,bt_quit=SimpleButton("Quit"),
  534.                                              End,
  535.                                       End,
  536.                                 End,
  537.                                 SubWindow,confwin,
  538.         End;
  539.  
  540.  DoMethod(win,MUIM_Notify,MUIA_Window_CloseRequest,TRUE,App,2,MUIM_Application_ReturnID,MUIV_Application_ReturnID_Quit);
  541.  DoMethod(dlist,MUIM_Notify,MUIA_Listview_DoubleClick,TRUE,App,2,MUIM_Application_ReturnID,ID_CONFIG);
  542.  DoMethod(bt_edit,MUIM_Notify,MUIA_Pressed,FALSE,App,2,MUIM_Application_ReturnID,ID_EDIT);
  543.  DoMethod(confwin,MUIM_Notify,MUIA_Window_CloseRequest,TRUE,App,2,MUIM_Application_ReturnID,ID_CONFIGC);
  544.  DoMethod(bt_c_cancel,MUIM_Notify,MUIA_Pressed,FALSE,App,2,MUIM_Application_ReturnID,ID_CONFIGC);
  545.  DoMethod(bt_c_ok,MUIM_Notify,MUIA_Pressed,FALSE,App,2,MUIM_Application_ReturnID,ID_CONFIGOK);
  546.  DoMethod(bt_delete,MUIM_Notify,MUIA_Pressed,FALSE,App,2,MUIM_Application_ReturnID,ID_DELETE);
  547.  DoMethod(bt_do,MUIM_Notify,MUIA_Pressed,FALSE,App,2,MUIM_CallHook,&do_hook);
  548.  DoMethod(bt_quit,MUIM_Notify,MUIA_Pressed,FALSE,App,2,MUIM_Application_ReturnID,MUIV_Application_ReturnID_Quit);
  549.  DoMethod(bt_about,MUIM_Notify,MUIA_Pressed,FALSE,App,2,MUIM_CallHook,&mabout_hook);
  550.  DoMethod(bt_c_help,MUIM_Notify,MUIA_Pressed,FALSE,App,2,MUIM_CallHook,&chelp_hook);
  551.  
  552.  set(win,MUIA_Window_Open,TRUE);
  553.  
  554.  while (running) {
  555.      switch (id=DoMethod(App,MUIM_Application_Input,&signals))
  556.          {
  557.              case MUIV_Application_ReturnID_Quit:
  558.                  running=FALSE;
  559.                  break;
  560.              case ID_CONFIG:
  561.                  DoMethod(dlist,MUIM_List_GetEntry,MUIV_List_GetEntry_Active,&cname);
  562.                  data=rconfig(cname->fib_FileName);
  563.                  set(info,MUIA_Text_Contents,data.info);
  564.                  break;
  565.              case ID_EDIT:
  566.                  DoMethod(dlist,MUIM_List_GetEntry,MUIV_List_GetEntry_Active,&cname);
  567.                  if (cname==NULL) {
  568.                      stccpy(data.prgname,"Unknown",8);
  569.                      stccpy(data.name,"Unnamed",8);
  570.                      stccpy(data.format," ",1);
  571.                      stccpy(data.info,"Unnamed Configuartion",22);
  572.                      }
  573.                  else if (!stricmp(data.name,cname->fib_FileName))
  574.                      data=rconfig(cname->fib_FileName);
  575.                  setconfwin(data);
  576.                  set(confwin,MUIA_Window_Open,TRUE);
  577.                  set(win,MUIA_Window_Sleep,TRUE);
  578.                  break;
  579.              case ID_CONFIGOK:
  580.                  set(confwin,MUIA_Window_Open,FALSE);
  581.                  set(win,MUIA_Window_Sleep,FALSE);
  582.                  data=getconfwin();
  583.                  wconfig(data);
  584.                  DoMethod(dlist,MUIM_Dirlist_ReRead);
  585.                  data=rconfig(data.name);
  586.                  break;
  587.              case ID_CONFIGC:
  588.                  set(confwin,MUIA_Window_Open,FALSE);
  589.                  set(win,MUIA_Window_Sleep,FALSE);
  590.                  setconfwin(data);
  591.                  data=rconfig(cname->fib_FileName);
  592.                  break;
  593.              case ID_DELETE:
  594.                  {
  595.                  char *fname=(char *)malloc(sizeof(char)*256);
  596.  
  597.                  sprintf(fname,"%s%s",ENVARCPATH,data.name);
  598.                  DeleteFile(fname);
  599.                  sprintf(fname,"%s%s",ENVPATH,data.name);
  600.                  DeleteFile(fname);
  601.                  DoMethod(dlist,MUIM_Dirlist_ReRead);
  602.                  }
  603.                  break;
  604.              }
  605.      if (running && signals) Wait(signals);
  606.      }
  607.  set(win,MUIA_Window_Open,FALSE);
  608.  fail(App,NULL);
  609.  }
  610. /*END*/
  611.